home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / c / bchelp10.zip / TI709.ASC < prev    next >
Text File  |  1991-09-18  |  3KB  |  133 lines
  1.  
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.   PRODUCT  :  C++                                    NUMBER  :  709
  9.   VERSION  :  All
  10.        OS  :  DOS
  11.      DATE  :  September 18, 1991                       PAGE  :  1/2
  12.  
  13.     TITLE  :  Calling Operators from Member Functions
  14.  
  15.  
  16.  
  17.  
  18.   The following provides examples of different ways to invoke an
  19.   operator, how to call such operators from within a member
  20.   function, and deals with some related multiple inheritance
  21.   issues.
  22.  
  23.   You can always invoke an operator by name. For example, given:
  24.  
  25.           X_Class
  26.           {
  27.                   ...
  28.                   public:
  29.                       X_Class &operator +( X_Class y);
  30.           };
  31.  
  32.           X_Class  x, y;
  33.  
  34.   the function for the + operator can be invoked in several ways:
  35.  
  36.           x + y;
  37.           x.operator +(y);
  38.  
  39.   We can think of the second example in this way: not only have we
  40.   overloaded the + operator to add together instances of the
  41.   X_Class, we also created a member function of the X_Class whose
  42.   name is operator +.
  43.  
  44.   If X_Class has a member function foo, and we want to call the +
  45.   operator from within it, we would do it by using its member
  46.   function name:
  47.  
  48.           X_Class::foo(X_Class &y)
  49.           {
  50.             ...
  51.             operator +(y);
  52.             ...
  53.           }
  54.  
  55.   If one is dealing with multiple inheritance, and operator + has
  56.   been redefined in several different classes, one might get an
  57.   ambiguity at some point.  To resolve this, or any other ambiguity
  58.   the compiler faces when it cannot determine which of the
  59.   overloaded functions it must use, you can qualify a member
  60.   function name with its class name.  For example suppose we have:
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70.  
  71.  
  72.  
  73.  
  74.   PRODUCT  :  C++                                    NUMBER  :  709
  75.   VERSION  :  All
  76.        OS  :  DOS
  77.      DATE  :  September 18, 1991                       PAGE  :  2/2
  78.  
  79.     TITLE  :  Calling Operators from Member Functions
  80.  
  81.  
  82.  
  83.  
  84.                                   A     B
  85.                                    \   /
  86.                                      C
  87.  
  88.   and there is a public A & operator +( int ) defined for both A
  89.   and B, and both  A and B are inherited publicly into C. Then
  90.  
  91.           A ans;
  92.           C c1;
  93.  
  94.           ans = c1 + 4;
  95.  
  96.   will be ambiguous.  It can be resolved by going,
  97.  
  98.           ans = c1.B::operator +(4);
  99.                   or
  100.           ans = c1.A::operator +(4);
  101.  
  102.   depending on which one you wanted to use.  This is because :: is
  103.   the scope operator.  It is used to specify which scope a given
  104.   symbol comes from.
  105.  
  106.  
  107.  
  108.  
  109.  
  110.  
  111.  
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120.  
  121.  
  122.  
  123.  
  124.  
  125.  
  126.  
  127.  
  128.  
  129.  
  130.  
  131.  
  132.  
  133.